home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / Q-R / RIFF File Format / MAZstuff.c < prev    next >
Encoding:
Text File  |  1993-12-14  |  5.8 KB  |  254 lines  |  [TEXT/KAHL]
  1. /*
  2. mod 10 29 86 tsh - put MOVEM's back in!
  3. mod 10 18 86 tsh - LSC 1.41 version
  4. mod 9 14 86 tsh - fix symbol for cpybuf
  5. MOD 08-28-86 MAZ - cpybuf, fillbuffer and long versions in ass'y code
  6. */
  7.  
  8. /* copy buffer of size from source to dest */
  9. longcpybuf(dest,source,size)
  10.   char *dest;
  11.   char *source;
  12.   long size;
  13.     {
  14.     asm
  15.         {
  16.         MOVE.L    A2,-(SP)        ; save A2
  17.         MOVEA.L    dest,A0            ; COPY dest
  18.         MOVE.L    source,A1        ; COPY source
  19.         MOVE.L    size,D2            ; LONG-EXTEND SIZE
  20.         BLE.S    @3
  21.  
  22. ; NONZERO MOVE
  23.         CMPA.L    A0,A1            ; SOURCE <CMP> DEST
  24.         BGT.S    @4
  25. ; TEST FOR OVERLAP
  26.         MOVE.L    A1,A2
  27.         ADDA.L    D2,A2            ; MAKE ONE PAST SOURCE BUF (SRCEND)
  28.         CMPA.L    A2,A0            ; DEST <CMP> SRCEND
  29.         BGE.S    @4                ; IMPLIES NO OVERLAP
  30.         ADDA.L    D2,A0            ; MAKE END OF DEST ARRAY
  31. ; BACKWARDS LOOP
  32.         MOVE.L    D2,D0
  33.         LSR.L    #3,D0            ; COMPUTE BATCHES
  34.         BEQ.S    @2                ; GO FINISH UP REMAINDER - SMALL MOVE
  35.         ANDI.B    #7,D2            ; TAKE REMAINDER (NOTE GUARANTEED SMALL)
  36. @1:        MOVE.B    -(A2),-(A0)
  37.         MOVE.B    -(A2),-(A0)
  38.         MOVE.B    -(A2),-(A0)
  39.         MOVE.B    -(A2),-(A0)
  40.         MOVE.B    -(A2),-(A0)
  41.         MOVE.B    -(A2),-(A0)
  42.         MOVE.B    -(A2),-(A0)
  43.         MOVE.B    -(A2),-(A0)
  44.         SUBQ.L    #1,D0            ; ONE LESS BATCH
  45.         BGT.S    @1
  46.         TST.B    D2                ; ANY ODD STUFF LEFT?
  47.         BEQ.S    @3
  48. ; PROCESS 7 OR LESS MOVES
  49. @2:        MOVE.B    -(A2),-(A0)        ; MOVE A BYTE
  50.         SUBQ.B    #1,D2
  51.         BGT.S    @2
  52. @3:        MOVE.L    (SP)+,A2        ; restore A2
  53.         return
  54.  
  55. ; FORWARDS LOOP
  56. @4:        MOVE.L    D2,D0
  57.         LSR.L    #3,D0            ; COMPUTE BATCHES
  58.         BEQ.S    @6                ; GO FINISH UP REMAINDER - SMALL MOVE
  59.         ANDI.B    #7,D2            ; TAKE REMAINDER (NOTE GUARANTEED SMALL)
  60. @5:        MOVE.B    (A1)+,(A0)+
  61.         MOVE.B    (A1)+,(A0)+
  62.         MOVE.B    (A1)+,(A0)+
  63.         MOVE.B    (A1)+,(A0)+
  64.         MOVE.B    (A1)+,(A0)+
  65.         MOVE.B    (A1)+,(A0)+
  66.         MOVE.B    (A1)+,(A0)+
  67.         MOVE.B    (A1)+,(A0)+
  68.         SUBQ.L    #1,D0            ; ONE LESS BATCH
  69.         BGT.S    @5
  70.         TST.B    D2                ; ANY ODD STUFF LEFT?
  71.         BEQ.S    @3
  72. ; PROCESS 7 OR LESS MOVES
  73. @6:        MOVE.B    (A1)+,(A0)+
  74.         SUBQ.B    #1,D2
  75.         BGT.S    @6
  76.         MOVE.L    (SP)+,A2        ; restore A2
  77.         return
  78.         }
  79.     }
  80.  
  81. /* copy buffer of size from source to dest */
  82. cpybuf(dest,source,size)
  83.   char *dest;
  84.   char *source;
  85.   short size;
  86.     {
  87.     asm
  88.         {
  89.         MOVE.L    A2,-(SP)        ; save A2
  90.         MOVEA.L    dest,A0
  91.         MOVE.L    source,A1        ; COPY SOURCE
  92.         MOVEQ    #0,D2
  93.         MOVE.W    size,D2            ; LONG-EXTEND SIZE
  94.         BLE.S    @3
  95.  
  96. ; NONZERO MOVE
  97.         CMPA.L    A0,A1            ; SOURCE <CMP> A0
  98.         BGT.S    @4
  99. ; TEST FOR OVERLAP
  100.         MOVE.L    A1,A2
  101.         ADDA.L    D2,A2            ; MAKE ONE PAST SOURCE BUF (SRCEND)
  102.         CMPA.L    A2,A0            ; DEST <CMP> SRCEND
  103.         BGE.S    @4                ; IMPLIES NO OVERLAP
  104.         ADDA.L    D2,A0            ; MAKE END OF DEST ARRAY
  105. ; BACKWARDS LOOP
  106.         MOVE.L    D2,D0
  107.         LSR.L    #3,D0            ; COMPUTE BATCHES
  108.         BEQ.S    @2                ; GO FINISH UP REMAINDER - SMALL MOVE
  109.         ANDI.B    #7,D2            ; TAKE REMAINDER (NOTE GUARANTEED SMALL)
  110. @1:        MOVE.B    -(A2),-(A0)
  111.         MOVE.B    -(A2),-(A0)
  112.         MOVE.B    -(A2),-(A0)
  113.         MOVE.B    -(A2),-(A0)
  114.         MOVE.B    -(A2),-(A0)
  115.         MOVE.B    -(A2),-(A0)
  116.         MOVE.B    -(A2),-(A0)
  117.         MOVE.B    -(A2),-(A0)
  118.         SUBQ.L    #1,D0            ; ONE LESS BATCH
  119.         BGT.S    @1
  120.         TST.B    D2                ; ANY ODD STUFF LEFT?
  121.         BEQ.S    @3
  122. ; PROCESS 7 OR LESS MOVES
  123. @2:        MOVE.B    -(A2),-(A0)        ; MOVE A BYTE
  124.         SUBQ.B    #1,D2
  125.         BGT.S    @2
  126. @3:        MOVE.L    (SP)+,A2        ; restore A2
  127.         return
  128.  
  129. ; FORWARDS LOOP
  130. @4:        MOVE.L    D2,D0
  131.         LSR.L    #3,D0            ; COMPUTE BATCHES
  132.         BEQ.S    @6                ; GO FINISH UP REMAINDER - SMALL MOVE
  133.         ANDI.B    #7,D2            ; TAKE REMAINDER (NOTE GUARANTEED SMALL)
  134. @5:        MOVE.B    (A1)+,(A0)+
  135.         MOVE.B    (A1)+,(A0)+
  136.         MOVE.B    (A1)+,(A0)+
  137.         MOVE.B    (A1)+,(A0)+
  138.         MOVE.B    (A1)+,(A0)+
  139.         MOVE.B    (A1)+,(A0)+
  140.         MOVE.B    (A1)+,(A0)+
  141.         MOVE.B    (A1)+,(A0)+
  142.         SUBQ.L    #1,D0            ; ONE LESS BATCH
  143.         BGT.S    @5
  144.         TST.B    D2                ; ANY ODD STUFF LEFT?
  145.         BEQ.S    @3
  146. ; PROCESS 7 OR LESS MOVES
  147. @6:        MOVE.B    (A1)+,(A0)+
  148.         SUBQ.B    #1,D2
  149.         BGT.S    @6
  150.         MOVE.L    (SP)+,A2         ;restore A2
  151.         return
  152.         }
  153.     }
  154.  
  155. /* fill buffer with given character, long length */
  156. longfillbuffer(p, size, c)
  157.   char *p;
  158.   long size;
  159.   char c;
  160.     {
  161.     asm
  162.         {
  163.         MOVEM.L    D3-D5,-(SP)        ; save reg's
  164.         MOVE.L    12(A6),D1        ; LOAD LONG SIZE
  165.         MOVE.W    16(A6),D2        ; LOAD BYTE TO FILL WITH
  166.         MOVEA.L    8(A6),A0        ; LOAD P
  167.         MOVE.L    A0,D0
  168.         BTST    #0,D0            ; IS P ODD?
  169.         BEQ.S    @NOTODD
  170.         MOVE.B    D2,(A0)+        ; *P++ = CH;
  171.         SUBQ.L    #1,D1            ; SIZE--;
  172. NOTODD:    MOVEA.L    A0,A1            ; Q =  P + SIZE;
  173.         ADDA.L    D1,A1
  174. EBYTES:    MOVE.B    D1,D3            ; WHILE (SIZE&0XF)
  175.         ANDI.B    #0x0F,D3
  176.         BEQ.S    @READYFILL        ;   {
  177.         MOVE.B    D2,-(A1)        ;   *--Q = CH;
  178.         SUBQ.L    #1,D1            ;   SIZE--;
  179.         BRA.S    @EBYTES            ;   }
  180. READYFILL:
  181.         TST.L    D1                ; IF (SIZE)
  182.         BEQ.S    @DONEFILL        ;   {
  183. ; CREATE 16 BYTES OF PATTERN IN D2-D5
  184.         ANDI.W    #0xFF,D2
  185.         MOVE.W    D2,D3
  186.         LSL.W    #8,D3
  187.         ADD.W    D2,D3
  188.         MOVE.W    D3,D2
  189.         SWAP    D2
  190.         MOVE.W    D3,D2
  191.         MOVE.L    D2,D3
  192.         MOVE.L    D2,D4
  193.         MOVE.L    D2,D5            ; D2-D5 = 16 BYTES OF FILL CHAR
  194.         MOVEQ    #16,D0            ; amount to decrement the count
  195. LFLP:    MOVEM.L    D2-D5,-(A1)        ; fill 16 bytes (backwards through buffer)
  196.         SUB.L    D0,D1            ; D1 := D1 - 16
  197.         BGT.S    @LFLP            ; loop
  198. DONEFILL:
  199.         MOVEM.L    (SP)+,D3-D5        ; restore reg's
  200.         return
  201.         }
  202.     }
  203.  
  204. /* fill buffer with given character, short length */
  205. fillbuffer(p,size,c)
  206.   char *p;
  207.   short size;
  208.   char c;
  209.     {
  210.     asm
  211.         {
  212.         MOVEM.L    D3-D5,-(SP)        ; save reg's
  213.         MOVEQ    #0,D1
  214.         MOVE.W    12(A6),D1        ; LOAD LONG-EXTENDED SIZE
  215.         MOVE.W    14(A6),D2        ; LOAD BYTE TO FILL WITH
  216. COMMONFILL:                        ; BRANCH HERE FOR LONG SIZE CASE.
  217.         MOVEA.L    8(A6),A0        ; LOAD P
  218.         MOVE.L    A0,D0
  219.         BTST    #0,D0            ; IS P ODD?
  220.         BEQ.S    @NOTODD
  221.         MOVE.B    D2,(A0)+        ; *P++ = CH;
  222.         SUBQ.L    #1,D1            ; SIZE--;
  223. NOTODD:    MOVEA.L    A0,A1            ; Q =  P + SIZE;
  224.         ADDA.L    D1,A1
  225. EBYTES:    MOVE.B    D1,D3            ; WHILE (SIZE&0XF)
  226.         ANDI.B    #0x0F,D3
  227.         BEQ.S    @READYFILL        ;   {
  228.         MOVE.B    D2,-(A1)        ;   *--Q = CH;
  229.         SUBQ.L    #1,D1            ;   SIZE--;
  230.         BRA.S    @EBYTES            ;   }
  231. READYFILL:
  232.         TST.L    D1                ; IF (SIZE)
  233.         BEQ.S    @DONEFILL        ;   {
  234. ; CREATE 16 BYTES OF PATTERN IN D2-D5
  235.         ANDI.W    #0xFF,D2
  236.         MOVE.W    D2,D3
  237.         LSL.W    #8,D3
  238.         ADD.W    D2,D3
  239.         MOVE.W    D3,D2
  240.         SWAP    D2
  241.         MOVE.W    D3,D2
  242.         MOVE.L    D2,D3
  243.         MOVE.L    D2,D4
  244.         MOVE.L    D2,D5            ; D2-D5 = 16 BYTES OF FILL CHAR
  245.         MOVEQ    #16,D0            ; amount to decrement the count
  246. LFLP:    MOVEM.L    D2-D5,-(A1)        ; fill 16 bytes (backwards through buffer)
  247.         SUB.L    D0,D1            ; D1 := D1 - 16
  248.         BGT.S    @LFLP            ; loop
  249. DONEFILL:
  250.         MOVEM.L    (SP)+,D3-D5        ; restore reg's
  251.         return
  252.         }
  253.     }
  254.